diff --git a/cmd/entire/cli/paths/paths.go b/cmd/entire/cli/paths/paths.go
--- a/cmd/entire/cli/paths/paths.go
+++ b/cmd/entire/cli/paths/paths.go
@@ -7,6 +7,7 @@
 	"os/exec"
 	"path/filepath"
 	"regexp"
+	"runtime"
 	"strings"
 	"sync"
 
@@ -155,6 +156,15 @@
 // ToRelativePath converts an absolute path to relative.
 // Returns empty string if the path is outside the working directory.
 func ToRelativePath(absPath, cwd string) string {
+	absPath = NormalizeMSYSPath(absPath)
+
+	// After MSYS normalization, a path starting with "/" that the OS still
+	// doesn't recognize as absolute is an unconvertible Unix path (e.g.,
+	// /home/user/... from a container/sandbox on Windows). Filter it out.
+	if strings.HasPrefix(absPath, "/") && !filepath.IsAbs(absPath) {
+		return ""
+	}
+
 	if !filepath.IsAbs(absPath) {
 		return absPath
 	}
@@ -166,6 +176,34 @@
 	return relPath
 }
 
+// msysDrivePrefix matches MSYS/Git-Bash-style absolute paths like /c/ or /D/.
+// Git for Windows executes hooks through MSYS2 bash, which converts Windows paths
+// (C:\Users\...) to Unix-style (/c/Users/...) in tool output and transcripts.
+var msysDrivePrefix = regexp.MustCompile(`^/([a-zA-Z])/`)
+
+// NormalizeMSYSPath converts MSYS/Git-Bash paths to Windows paths.
+// Handles two MSYS conventions:
+//   - Drive paths: /c/Users/... → C:/Users/...
+//   - Virtual dirs: /tmp/... → <TEMP>/... (MSYS2 maps /tmp to the Windows temp dir)
+//
+// Returns the input unchanged on non-Windows or if the path doesn't match.
+func NormalizeMSYSPath(p string) string {
+	if runtime.GOOS != "windows" {
+		return p
+	}
+
+	if m := msysDrivePrefix.FindStringSubmatch(p); m != nil {
+		return strings.ToUpper(m[1]) + ":/" + p[3:]
+	}
+	// MSYS2 maps /tmp to the Windows temp directory.
+	if strings.HasPrefix(p, "/tmp/") {
+		if tmp := os.TempDir(); tmp != "" {
+			return filepath.Join(tmp, p[5:])
+		}
+	}
+	return p
+}
+
 // nonAlphanumericRegex matches any non-alphanumeric character
 var nonAlphanumericRegex = regexp.MustCompile(`[^a-zA-Z0-9]`)
 

diff --git a/cmd/entire/cli/paths/paths_test.go b/cmd/entire/cli/paths/paths_test.go
--- a/cmd/entire/cli/paths/paths_test.go
+++ b/cmd/entire/cli/paths/paths_test.go
@@ -3,6 +3,7 @@
 import (
 	"os"
 	"path/filepath"
+	"runtime"
 	"testing"
 )
 
@@ -121,3 +122,27 @@
 		t.Errorf("GetClaudeProjectDir() = %q, want %q", result, expected)
 	}
 }
+
+func TestNormalizeMSYSPath_NonWindows_NoRewrite(t *testing.T) {
+	t.Parallel()
+
+	if runtime.GOOS == "windows" {
+		t.Skip("non-Windows behavior test")
+	}
+
+	tests := []string{
+		"/c/Users/test/repo/file.txt",
+		"/D/work/project/main.go",
+		"/tmp/repo/file.txt",
+		"/tmp",
+	}
+
+	for _, input := range tests {
+		t.Run(input, func(t *testing.T) {
+			got := NormalizeMSYSPath(input)
+			if got != input {
+				t.Errorf("NormalizeMSYSPath(%q) = %q, want unchanged %q", input, got, input)
+			}
+		})
+	}
+}

diff --git a/cmd/entire/cli/state.go b/cmd/entire/cli/state.go
--- a/cmd/entire/cli/state.go
+++ b/cmd/entire/cli/state.go
@@ -7,6 +7,7 @@
 	"fmt"
 	"log/slog"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 	"time"
@@ -288,64 +289,89 @@
 // filterToUncommittedFiles removes files from the list that are already committed to HEAD
 // with matching content. This prevents re-adding files that an agent committed mid-turn
 // (already condensed by PostCommit) back to FilesTouched via SaveStep. Files not in
-// HEAD or with different content in the working tree are kept. Fails open: if any git
-// operation errors, returns the original list unchanged.
+// HEAD or with different content in the working tree are kept. Fails open: if git
+// errors (e.g. bare repo, no HEAD), returns the original list unchanged.
+//
+// Uses the git CLI instead of go-git to avoid index lock contention on Windows and
+// to ensure consistent autocrlf/eol handling (git CLI respects system-level config,
+// while go-git's content comparison would need manual CRLF normalization).
 func filterToUncommittedFiles(ctx context.Context, files []string, repoRoot string) []string {
 	if len(files) == 0 {
 		return files
 	}
 
-	repo, err := openRepository(ctx)
+	// git diff --name-only HEAD -- <files> prints files that differ from HEAD.
+	// Empty output means tracked files match HEAD, but it does NOT include untracked files.
+	// We handle untracked files separately via git ls-files --others.
+	args := append([]string{"diff", "--name-only", "HEAD", "--"}, files...)
+	cmd := exec.CommandContext(ctx, "git", args...)
+	cmd.Dir = repoRoot
+	out, err := cmd.Output()
 	if err != nil {
-		return files // fail open
+		// Capture stderr for diagnostics (exec.ExitError carries it).
+		var stderr string
+		var exitErr *exec.ExitError
+		if errors.As(err, &exitErr) {
+			stderr = string(exitErr.Stderr)
+		}
+		// Fail open: no HEAD (empty repo, initial commit), not a git repo, etc.
+		logging.Warn(ctx, "filterToUncommittedFiles: git diff failed, keeping all files as uncommitted",
+			slog.String("error", err.Error()),
+			slog.String("stderr", stderr),
+			slog.String("dir", repoRoot),
+			slog.Any("files", files))
+		return files
 	}
 
-	head, err := repo.Head()
-	if err != nil {
-		return files // fail open (empty repo, detached HEAD, etc.)
+	// git ls-files --others -- <files> prints untracked files (including ignored ones).
+	// This preserves the contract that files not in HEAD are kept as uncommitted.
+	untrackedArgs := append([]string{"ls-files", "--others", "--"}, files...)
+	untrackedCmd := exec.CommandContext(ctx, "git", untrackedArgs...)
+	untrackedCmd.Dir = repoRoot
+	untrackedOut, untrackedErr := untrackedCmd.Output()
+	if untrackedErr != nil {
+		var stderr string
+		var exitErr *exec.ExitError
+		if errors.As(untrackedErr, &exitErr) {
+			stderr = string(exitErr.Stderr)
+		}
+		logging.Warn(ctx, "filterToUncommittedFiles: git ls-files failed, keeping all files as uncommitted",
+			slog.String("error", untrackedErr.Error()),
+			slog.String("stderr", stderr),
+			slog.String("dir", repoRoot),
+			slog.Any("files", files))
+		return files
 	}
 
-	commit, err := repo.CommitObject(head.Hash())
-	if err != nil {
-		return files // fail open
+	trimmed := strings.TrimRight(string(out), "\n")
+	trimmedUntracked := strings.TrimRight(string(untrackedOut), "\n")
+	if trimmed == "" && trimmedUntracked == "" {
+		return nil // all files are committed with matching content
 	}
 
-	headTree, err := commit.Tree()
-	if err != nil {
-		return files // fail open
+	// Build sets of files that are uncommitted:
+	// - files differing from HEAD
+	// - files not tracked in HEAD (currently untracked)
+	diffSet := make(map[string]bool)
+	for _, line := range strings.Split(trimmed, "\n") {
+		if line != "" {
+			diffSet[filepath.ToSlash(line)] = true
+		}
 	}
+	untrackedSet := make(map[string]bool)
+	for _, line := range strings.Split(trimmedUntracked, "\n") {
+		if line != "" {
+			untrackedSet[filepath.ToSlash(line)] = true
+		}
+	}
 
 	var result []string
-	for _, relPath := range files {
-		headFile, err := headTree.File(relPath)
-		if err != nil {
-			// File not in HEAD — it's uncommitted
-			result = append(result, relPath)
-			continue
+	for _, f := range files {
+		path := filepath.ToSlash(f)
+		if diffSet[path] || untrackedSet[path] {
+			result = append(result, f)
 		}
-
-		// File is in HEAD — compare content with working tree
-		absPath := filepath.Join(repoRoot, relPath)
-		workingContent, err := os.ReadFile(absPath) //nolint:gosec // path from controlled source
-		if err != nil {
-			// Can't read working tree file (deleted?) — keep it
-			result = append(result, relPath)
-			continue
-		}
-
-		headContent, err := headFile.Contents()
-		if err != nil {
-			result = append(result, relPath)
-			continue
-		}
-
-		if string(workingContent) != headContent {
-			// Working tree differs from HEAD — uncommitted changes
-			result = append(result, relPath)
-		}
-		// else: content matches HEAD — already committed, skip
 	}
-
 	return result
 }
 

diff --git a/cmd/entire/cli/state_test.go b/cmd/entire/cli/state_test.go
--- a/cmd/entire/cli/state_test.go
+++ b/cmd/entire/cli/state_test.go
@@ -9,6 +9,7 @@
 
 	"github.com/entireio/cli/cmd/entire/cli/agent/claudecode"
 	"github.com/entireio/cli/cmd/entire/cli/paths"
+	"github.com/entireio/cli/cmd/entire/cli/testutil"
 	"github.com/go-git/go-git/v6"
 	"github.com/go-git/go-git/v6/plumbing/object"
 	"github.com/stretchr/testify/require"
@@ -796,3 +797,55 @@
 		})
 	}
 }
+
+func TestFilterToUncommittedFiles_KeepsUntrackedFiles(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+	testutil.InitRepo(t, tmpDir)
+	testutil.WriteFile(t, tmpDir, "tracked.txt", "tracked content")
+	testutil.GitAdd(t, tmpDir, "tracked.txt")
+	testutil.GitCommit(t, tmpDir, "initial commit")
+
+	testutil.WriteFile(t, tmpDir, "untracked.txt", "new file content")
+
+	files := []string{"tracked.txt", "untracked.txt"}
+	got := filterToUncommittedFiles(context.Background(), files, tmpDir)
+
+	want := []string{"untracked.txt"}
+	if len(got) != len(want) {
+		t.Fatalf("filterToUncommittedFiles() = %v, want %v", got, want)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Errorf("filterToUncommittedFiles()[%d] = %q, want %q", i, got[i], want[i])
+		}
+	}
+}
+
+func TestFilterToUncommittedFiles_KeepsTrackedDiffsAndUntracked(t *testing.T) {
+	t.Parallel()
+
+	tmpDir := t.TempDir()
+	testutil.InitRepo(t, tmpDir)
+	testutil.WriteFile(t, tmpDir, "tracked.txt", "tracked content")
+	testutil.GitAdd(t, tmpDir, "tracked.txt")
+	testutil.GitCommit(t, tmpDir, "initial commit")
+
+	// tracked.txt now differs from HEAD, and untracked.txt is not in HEAD.
+	testutil.WriteFile(t, tmpDir, "tracked.txt", "updated tracked content")
+	testutil.WriteFile(t, tmpDir, "untracked.txt", "new file content")
+
+	files := []string{"tracked.txt", "untracked.txt"}
+	got := filterToUncommittedFiles(context.Background(), files, tmpDir)
+
+	want := []string{"tracked.txt", "untracked.txt"}
+	if len(got) != len(want) {
+		t.Fatalf("filterToUncommittedFiles() = %v, want %v", got, want)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Errorf("filterToUncommittedFiles()[%d] = %q, want %q", i, got[i], want[i])
+		}
+	}
+}